var express = require('express');
var router = express.Router();
var aisaveModel = require('../db/aisave');
var aiimgModel = require('../db/aiimg');

// 保存AI分析结果
router.post('/save', async (req, res) => {
    try {
        console.log('📥 接收到保存分析结果请求');
        console.log('📋 请求数据:', JSON.stringify(req.body, null, 2));
        
        const { imageId, analysisData } = req.body;
        
        // 验证必要参数
        if (!imageId) {
            return res.status(400).json({
                code: 400,
                message: '缺少图片ID'
            });
        }
        
        if (!analysisData) {
            return res.status(400).json({
                code: 400,
                message: '缺少分析数据'
            });
        }
        
        // 验证图片是否存在
        const imageExists = await aiimgModel.findById(imageId);
        if (!imageExists) {
            return res.status(404).json({
                code: 404,
                message: '图片不存在'
            });
        }
        
        // 检查是否已存在分析结果
        const existingAnalysis = await aisaveModel.findOne({ imageId: imageId });
        if (existingAnalysis) {
            console.log('🔄 发现已存在的分析结果，进行更新');
            // 更新现有记录
            const updatedAnalysis = await aisaveModel.findByIdAndUpdate(
                existingAnalysis._id,
                {
                    analysisTime: new Date(),
                    ...extractAnalysisFields(analysisData)
                },
                { new: true }
            );
            
            return res.json({
                code: 200,
                message: '分析结果更新成功',
                data: updatedAnalysis
            });
        }
        
        // 创建新的分析结果记录
        console.log('🔄 开始保存分析数据...');
        
        // 直接保存分析数据，不进行复杂的字段提取
        const extractedFields = extractBasicFields(analysisData);
        console.log('✅ 基本字段提取完成:', Object.keys(extractedFields));
        
        console.log('🏗️ 创建新的分析记录...');
        const newAnalysis = new aisaveModel({
            imageId: imageId,
            ...extractedFields
        });
        
        console.log('💾 保存到数据库...');
        const savedAnalysis = await newAnalysis.save();
        console.log('✅ 分析结果保存成功，ID:', savedAnalysis._id);
        
        res.json({
            code: 200,
            message: '分析结果保存成功',
            data: savedAnalysis
        });
        
    } catch (error) {
        console.error('❌ 保存分析结果失败:', error);
        console.error('❌ 错误详情:', error.stack);
        console.error('❌ 错误名称:', error.name);
        console.error('❌ 错误消息:', error.message);
        res.status(500).json({
            code: 500,
            message: '保存失败',
            error: error.message,
            stack: process.env.NODE_ENV === 'development' ? error.stack : undefined
        });
    }
});

// 根据图片ID获取分析结果
router.get('/getByImageId', async (req, res) => {
    try {
        const { imageId } = req.query;
        
        if (!imageId) {
            return res.status(400).json({
                code: 400,
                message: '缺少图片ID'
            });
        }
        
        const analysis = await aisaveModel.findOne({ imageId: imageId })
            .populate('imageId', 'name img uploadTime originalName');
        
        if (!analysis) {
            return res.status(404).json({
                code: 404,
                message: '未找到分析结果'
            });
        }
        
        res.json({
            code: 200,
            message: '获取成功',
            data: analysis
        });
        
    } catch (error) {
        console.error('❌ 获取分析结果失败:', error);
        res.status(500).json({
            code: 500,
            message: '获取失败',
            error: error.message
        });
    }
});

// 获取所有分析结果列表
router.get('/list', async (req, res) => {
    try {
        const { page = 1, limit = 10, gender, ageRange, startDate, endDate } = req.query;
        const skip = (page - 1) * parseInt(limit);
        
        // 构建查询条件
        let query = {};
        
        // 性别筛选
        if (gender) {
            query['gender.gender'] = gender === 'male' ? 'male' : 'female';
        }
        
        // 年龄段筛选
        if (ageRange) {
            console.log('📊 收到年龄段筛选条件:', ageRange);
            
            try {
                // 处理 "75+" 格式
                if (ageRange.includes('+')) {
                    const minAge = parseInt(ageRange.replace('+', ''));
                    if (!isNaN(minAge)) {
                        query['age.age'] = { $gte: minAge };
                        console.log('📊 年龄段筛选 (大于等于):', minAge);
                    }
                } 
                // 处理 "18-24" 格式
                else if (ageRange.includes('-')) {
                    const [minAge, maxAge] = ageRange.split('-');
                    const minAgeNum = parseInt(minAge);
                    const maxAgeNum = parseInt(maxAge);
                    
                    if (!isNaN(minAgeNum) && !isNaN(maxAgeNum)) {
                        query['age.age'] = { 
                            $gte: minAgeNum, 
                            $lte: maxAgeNum 
                        };
                        console.log('📊 年龄段筛选 (范围):', minAgeNum, '-', maxAgeNum);
                    }
                }
                // 处理单个年龄值
                else {
                    const age = parseInt(ageRange);
                    if (!isNaN(age)) {
                        query['age.age'] = age;
                        console.log('📊 年龄段筛选 (精确):', age);
                    }
                }
            } catch (error) {
                console.error('❌ 年龄段筛选条件解析错误:', error);
                console.log('📊 跳过年龄段筛选');
            }
        }
        
        // 时间范围筛选
        if (startDate && endDate) {
            query.analysisTime = {
                $gte: new Date(startDate),
                $lte: new Date(endDate + ' 23:59:59')
            };
        }
        
        console.log('🔍 查询条件:', query);
        
        const analysisList = await aisaveModel.find(query)
            .populate('imageId', 'name img uploadTime originalName fileSize mimeType')
            .sort({ analysisTime: -1 })
            .skip(skip)
            .limit(parseInt(limit));
        
        const total = await aisaveModel.countDocuments(query);
        
        // 格式化数据以匹配前端期望的格式
        const formattedList = analysisList.map(item => {
            const imageUrl = item.imageId && item.imageId.img ? 
                `http://localhost:3000${item.imageId.img}` : null;
            
            return {
                id: item._id,
                imageUrl: imageUrl,
                faceCount: item.faceCount || 0,
                gender: item.gender ? (item.gender.gender === 'male' ? '男性' : '女性') : '未知',
                age: item.age ? item.age.age : 0,
                goldenRatioScore: item.goldenRatio ? item.goldenRatio.totalScore || 0 : 0,
                mainEmotion: item.expressions ? item.expressions.dominant || '未知' : '未知',
                faceShape: item.features ? item.features.faceShape || '未知' : '未知',
                analysisTime: item.analysisTime ? new Date(item.analysisTime).toLocaleString('zh-CN') : '',
                aiAnalysis: item.aiAnalysis || '',
                beautifyRecommendations: item.beautifyRecommendations || '',
                rawData: item // 保留原始数据供详情查看
            };
        });
        
        res.json({
            code: 200,
            message: '获取成功',
            data: {
                list: formattedList,
                total: total,
                page: parseInt(page),
                limit: parseInt(limit),
                totalPages: Math.ceil(total / parseInt(limit))
            }
        });
        
    } catch (error) {
        console.error('❌ 获取分析结果列表失败:', error);
        res.status(500).json({
            code: 500,
            message: '获取失败',
            error: error.message
        });
    }
});

// 删除分析结果
router.delete('/delete/:id', async (req, res) => {
    try {
        const { id } = req.params;
        
        const deletedAnalysis = await aisaveModel.findByIdAndDelete(id);
        
        if (!deletedAnalysis) {
            return res.status(404).json({
                code: 404,
                message: '分析结果不存在'
            });
        }
        
        res.json({
            code: 200,
            message: '删除成功',
            data: deletedAnalysis
        });
        
    } catch (error) {
        console.error('❌ 删除分析结果失败:', error);
        res.status(500).json({
            code: 500,
            message: '删除失败',
            error: error.message
        });
    }
});

// 获取统计数据
router.get('/statistics', async (req, res) => {
    try {
        console.log('📊 开始获取AI分析统计数据...');
        
        // 获取总分析次数
        const totalAnalysis = await aisaveModel.countDocuments({});
        
        // 获取今日分析次数
        const today = new Date();
        today.setHours(0, 0, 0, 0);
        const tomorrow = new Date(today);
        tomorrow.setDate(tomorrow.getDate() + 1);
        
        const todayAnalysis = await aisaveModel.countDocuments({
            analysisTime: {
                $gte: today,
                $lt: tomorrow
            }
        });
        
        // 计算平均得分（基于黄金比例得分）
        const scoreAggregation = await aisaveModel.aggregate([
            {
                $match: {
                    'goldenRatio.totalScore': { $exists: true, $ne: null }
                }
            },
            {
                $group: {
                    _id: null,
                    avgScore: { $avg: '$goldenRatio.totalScore' },
                    count: { $sum: 1 }
                }
            }
        ]);
        
        const avgScore = scoreAggregation.length > 0 ? Math.round(scoreAggregation[0].avgScore) : 0;
        
        // 计算成功率（有分析结果的记录 / 总记录数）
        const successfulAnalysis = await aisaveModel.countDocuments({
            faceCount: { $gt: 0 }
        });
        
        const successRate = totalAnalysis > 0 ? Math.round((successfulAnalysis / totalAnalysis) * 100) : 0;
        
        const statistics = {
            totalAnalysis,
            todayAnalysis,
            avgScore,
            successRate,
            lastUpdateTime: new Date().toISOString()
        };
        
        console.log('✅ 统计数据计算完成:', statistics);
        
        res.json({
            code: 200,
            message: '获取统计数据成功',
            data: statistics
        });
        
    } catch (error) {
        console.error('❌ 获取统计数据失败:', error);
        res.status(500).json({
            code: 500,
            message: '获取统计数据失败',
            error: error.message
        });
    }
});

// 简化的基本字段提取函数
function extractBasicFields(analysisData) {
    console.log('🔍 开始提取分析字段');
    console.log('📊 分析数据类型:', typeof analysisData);
    console.log('📊 分析数据是否为空:', !analysisData);
    
    if (!analysisData || typeof analysisData !== 'object') {
        console.warn('⚠️ 分析数据无效，使用默认值');
        return {
            rawAnalysisData: analysisData,
            faceCount: 0,
            aiAnalysis: null,
            beautifyRecommendations: ''
        };
    }
    
    const result = {
        rawAnalysisData: analysisData, // 保存完整的原始数据
        faceCount: analysisData.faceCount || 0,
        aiAnalysis: analysisData.aiAnalysis || null,
        beautifyRecommendations: '' // 默认为空字符串
    };
    
    // 如果有人脸数据，提取第一张人脸的信息
    if (analysisData.faces && analysisData.faces.length > 0) {
        try {
            const face = analysisData.faces[0]; // 取第一张人脸
            console.log('👤 提取第一张人脸数据，类型:', typeof face);
        
            // 性别信息
            if (face.gender) {
                try {
                    result.gender = {
                        gender: face.gender.gender || 'unknown',
                        probability: face.gender.probability || '0'
                    };
                } catch (genderError) {
                    console.error('❌ 处理性别数据时出错:', genderError);
                }
            }
            
            // 年龄信息
            if (face.age) {
                try {
                    result.age = {
                        age: face.age.age || 0,
                        ageRange: face.age.ageRange || 'unknown'
                    };
                } catch (ageError) {
                    console.error('❌ 处理年龄数据时出错:', ageError);
                }
            }
            
            // 表情分析
            if (face.expressions) {
                try {
                    result.expressions = {
                        dominant: face.expressions.dominant || 'neutral',
                        confidence: face.expressions.confidence || '0',
                        scores: face.expressions.scores || {}
                    };
                } catch (expError) {
                    console.error('❌ 处理表情数据时出错:', expError);
                }
            }
            
            // 面部特征
            if (face.features) {
                try {
                    result.features = {
                        faceShape: face.features.faceShape || 'unknown',
                        eyeDistance: face.features.eyeDistance || 0,
                        noseLength: face.features.noseLength || 0,
                        mouthWidth: face.features.mouthWidth || 0,
                        faceDimensions: face.features.faceDimensions || {}
                    };
                } catch (featError) {
                    console.error('❌ 处理面部特征数据时出错:', featError);
                }
            }
        
            // 黄金比例分析
            if (face.goldenRatio) {
                try {
                    result.goldenRatio = {
                        totalScore: face.goldenRatio.totalScore || 0,
                        grade: face.goldenRatio.grade || 'Unknown',
                        details: face.goldenRatio.details || {},
                        summary: face.goldenRatio.summary || {}
                    };
                } catch (goldenError) {
                    console.error('❌ 处理黄金比例数据时出错:', goldenError);
                    console.warn('⚠️ 跳过黄金比例字段');
                }
            }
        
            // 基础比例分析
            if (face.proportions) {
                try {
                    result.proportions = {
                        faceRatio: face.proportions.faceRatio || 0,
                        faceRatioGrade: face.proportions.faceRatioGrade || 'Unknown',
                        threeCourtAnalysis: face.proportions.threeCourtAnalysis || {},
                        threeEyeAnalysis: face.proportions.threeEyeAnalysis || {}
                    };
                } catch (propError) {
                    console.error('❌ 处理比例数据时出错:', propError);
                }
            }
        
            // 直接保存美容建议为字符串
            if (face.beautifyRecommendations) {
                try {
                    if (typeof face.beautifyRecommendations === 'string') {
                        result.beautifyRecommendations = face.beautifyRecommendations;
                    } else if (Array.isArray(face.beautifyRecommendations)) {
                        // 如果是数组，转换为格式化的字符串
                        result.beautifyRecommendations = JSON.stringify(face.beautifyRecommendations, null, 2);
                    } else {
                        result.beautifyRecommendations = JSON.stringify(face.beautifyRecommendations);
                    }
                    console.log('✅ 美容建议保存为字符串，长度:', result.beautifyRecommendations.length);
                } catch (beautyError) {
                    console.error('❌ 处理美容建议时出错:', beautyError);
                    result.beautifyRecommendations = '';
                }
            } else {
                result.beautifyRecommendations = '';
            }
        } catch (faceError) {
            console.error('❌ 提取人脸数据时出错:', faceError);
            console.warn('⚠️ 使用基本字段继续保存');
        }
    }
    
    console.log('✅ 字段提取完成:', Object.keys(result));
    return result;
}


module.exports = router;
